home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 January: Mac OS SDK / Dev.CD Jan 96 SDK / Dev.CD Jan 96 SDK1.toast / Development Kits (Disc 1) / AppleScript / Development Tools / Sample Code / 7Edit / C Sources / SVEditUtils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-25  |  16.5 KB  |  621 lines  |  [TEXT/MPS ]
  1. /*
  2.     SVEditUtils.c
  3.     
  4.     Version 3.0d9
  5.     
  6.     Copyright © SRL Data 1992, 1993
  7.     
  8.     All rights reserved
  9.     
  10.     Produced by : SRL Data
  11.     Originally Developed for UK.DTS
  12. */
  13.  
  14.  
  15. /*
  16.     Changes for 3.0d4:
  17.         
  18.         5-Aug-92    : NH : Modified styles to use TEContinuousStyle like IM IV
  19.     
  20.     Changes for 3.0d6:
  21.         
  22.         9-Sep-92    : JL : Changed FeatureIsImplemented to use BitTst
  23.                          Added setting of gRecordingIsImplemented flag
  24. */
  25.  
  26. #include <PLStringFuncs.h>
  27. #include <Events.h>
  28. #include <Traps.h>
  29. #include <Dialogs.h>
  30. #include <Fonts.h>
  31. #include <Packages.h>
  32. #include <ToolUtils.h>
  33. #include <AppleEvents.h>
  34. #include "SVEditUtils.h"
  35.  
  36. /**-----------------------------------------------------------------------
  37.         Name:             LesserOf
  38.         Purpose:        Returns the Lesser of two longints.
  39.     -----------------------------------------------------------------------**/
  40. #pragma segment Utils
  41.         
  42. pascal long LesserOf(long A, long B)
  43.  {
  44.    if (A<B)
  45.        return(A);
  46.      else
  47.        return(B);
  48.  }   /*LesserOf*/
  49.             
  50. /**-----------------------------------------------------------------------
  51.         Name:             GreaterOf
  52.         Purpose:        Returns the Greater of two longints.
  53.     -----------------------------------------------------------------------**/
  54.     
  55. #pragma segment Utils
  56.         
  57. pascal long GreaterOf(long A, long B)
  58.  {
  59.    if (A>B)
  60.        return(A);
  61.      else
  62.        return(B);
  63.  }  /*GreaterOf*/
  64.             
  65. /**-----------------------------------------------------------------------
  66.         Name:             ShowError
  67.         Purpose:        Reports an error to the user as both string and number.
  68.     -----------------------------------------------------------------------**/
  69. #pragma segment Utils
  70.         
  71. pascal void ShowError(Str255  theError,
  72.                                           long    theErrorCode)
  73. {
  74.    short     alertResult;
  75.    Str255    theString;
  76.      OSErr     myErr;
  77.      
  78.      myErr = AEInteractWithUser(kAEDefaultTimeout, nil,nil);
  79.      
  80.      if (myErr == noErr)
  81.        {
  82.              SetCursor(&qd.arrow);
  83.              NumToString(theErrorCode, theString);
  84.              ParamText(theError, theString, (unsigned char *)"", (unsigned char *)"");
  85.              alertResult = Alert(300, nil);
  86.          }
  87. } /* ShowError */
  88.  
  89. /**-----------------------------------------------------------------------
  90.         Name:             Ours
  91.         Purpose:        Checks the frontmost window belongs to the app.
  92.     -----------------------------------------------------------------------**/
  93. #pragma segment Utils        
  94.     
  95. pascal Boolean Ours(WindowPtr aWindow)
  96.  {
  97.         if (aWindow)
  98.             if (((WindowPeek)aWindow)->windowKind == zoomDocProc)
  99.                 return(true);
  100.         return(false);
  101. } /* Ours */
  102.  
  103. /**-----------------------------------------------------------------------
  104.         Name:             SetShortMenus
  105.         Purpose:        Cuts the menus down to a minimum - Apple File Edit.
  106.                                 Greys out the unavailable options - used when no docs open
  107.     -----------------------------------------------------------------------**/
  108. #pragma segment Utils        
  109.  
  110. pascal void SetShortMenus()
  111. { 
  112.     DeleteMenu(mfontID);
  113.     DeleteMenu(sizeID);
  114.     DeleteMenu(styleID);
  115.  
  116.     DisableItem(myMenus[fileM], fmClose);
  117.     DisableItem(myMenus[fileM], fmSave);
  118.     DisableItem(myMenus[fileM], fmSaveAs);
  119.     DisableItem(myMenus[fileM], fmRevert);
  120.     DisableItem(myMenus[fileM], fmPrint);
  121.     DisableItem(myMenus[fileM], fmPageSetUp);
  122.  
  123.     /* now the unnecessary items on the edit menu */
  124.                 
  125.     DisableItem(myMenus[editM], undoCommand);
  126.     DisableItem(myMenus[editM], cutCommand);
  127.     DisableItem(myMenus[editM], copyCommand);
  128.     DisableItem(myMenus[editM], clearCommand);
  129.     DisableItem(myMenus[editM], pasteCommand);
  130.     DisableItem(myMenus[editM], selectAllCommand);
  131.  
  132.     DrawMenuBar();
  133. }  /* SetShortMenus */
  134.  
  135. /**-----------------------------------------------------------------------
  136.         Name:             SetLongMenus
  137.         Purpose:        Reinstates the full menu bar - called when first document
  138.                     opened.
  139.     -----------------------------------------------------------------------**/
  140. #pragma segment Utils        
  141.  
  142. pascal void SetLongMenus()
  143.   {
  144.         InsertMenu(myMenus[fontM], 0);
  145.         InsertMenu(myMenus[sizeM], 0);
  146.         InsertMenu(myMenus[styleM], 0);
  147.  
  148.         EnableItem(myMenus[fileM], fmClose);
  149.         EnableItem(myMenus[fileM], fmSave);
  150.         EnableItem(myMenus[fileM], fmSaveAs);
  151.         EnableItem(myMenus[fileM], fmRevert);
  152.         EnableItem(myMenus[fileM], fmPrint);
  153.         EnableItem(myMenus[fileM], fmPageSetUp);
  154.  
  155.         /* now the necessary items on the edit menu -
  156.             many other items fixed on each pass thru the main event
  157.             loop or before the window pulled down
  158.         */
  159.         
  160.         EnableItem(myMenus[editM], selectAllCommand);
  161.  
  162.         DrawMenuBar();
  163.     }  /* SetLongMenus */
  164.  
  165. /**-----------------------------------------------------------------------
  166.         Name:             SetStyleMenu
  167.         Purpose:        Sets the style menu checking to reflect the style of the
  168.                     first character of the current selection in the given
  169.                                 document.
  170.     -----------------------------------------------------------------------**/
  171. #pragma segment Utils        
  172.         
  173. pascal void SetStyleMenu(DPtr theDoc)
  174.   {
  175.     TextStyle        theTStyle;
  176.         short       contMode;
  177.         short       i;
  178.         
  179.         contMode = doFace;
  180.         
  181.         TEContinuousStyle(&contMode,&theTStyle,theDoc->theText);
  182.         
  183.         if ((contMode & doFace) != 0)
  184.             {
  185.                 CheckItem(myMenus[styleM], cPlain,     (theTStyle.tsFace == 0));
  186.                 CheckItem(myMenus[styleM], cBold,      (bold      & theTStyle.tsFace));
  187.                 CheckItem(myMenus[styleM], cItalic,    (italic    & theTStyle.tsFace));
  188.                 CheckItem(myMenus[styleM], cUnderline, (underline & theTStyle.tsFace));
  189.                 CheckItem(myMenus[styleM], cOutline,   (outline   & theTStyle.tsFace));
  190.                 CheckItem(myMenus[styleM], cShadow,    (shadow    & theTStyle.tsFace));
  191.                 CheckItem(myMenus[styleM], cCondense,  (condense  & theTStyle.tsFace));
  192.                 CheckItem(myMenus[styleM], cExtend,    (extend    & theTStyle.tsFace));
  193.           }
  194.         else
  195.             for (i=cPlain; i<= cExtend; i++)
  196.                 CheckItem(myMenus[styleM], i,     false);
  197.   }
  198.  
  199. /**-----------------------------------------------------------------------
  200.     Name:       SetSizeMenu
  201.     Purpose:    Outline all the items if the current font is an
  202.                 outline font. Check the size of the current selection
  203.   -----------------------------------------------------------------------**/
  204. #pragma segment Utils        
  205.  
  206. pascal void SetSizeMenu(DPtr theDoc)
  207.   {
  208.       short             i;
  209.         short                aSize;
  210.         short                max;
  211.     long                 theSize;
  212.     Str255        name;
  213.     Boolean       sizeinMenu;
  214.     Boolean       oldState;
  215.     Point         numer;
  216.     TextStyle        theStyle;
  217.         TEHandle    myText;
  218.         short       contMode;
  219.       
  220.     numer.h = 1;
  221.     numer.v = 1;
  222.  
  223.     myText = theDoc->theText;
  224.         
  225.         contMode = doSize+doFont;
  226.         
  227.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  228.         
  229.     sizeinMenu = false;
  230.     max = CountMItems(myMenus[sizeM]);
  231.         for (i = 1; i <= max - 5; i++)
  232.       {
  233.                 GetItem(myMenus[sizeM], i, name);
  234.                 StringToNum(name, &theSize);
  235.                 aSize = (short)theSize;
  236.  
  237.                 if (RealFont(theStyle.tsFont, aSize) && (contMode & doFont) != 0) // there is only one font and this size exists
  238.                     SetItemStyle(myMenus[sizeM], i, outline);
  239.                 else
  240.                     SetItemStyle(myMenus[sizeM], i, 0);
  241.  
  242.                 if ((aSize == theStyle.tsSize) && (contMode & doSize) != 0)
  243.                     {
  244.                         sizeinMenu = true;
  245.                         CheckItem(myMenus[sizeM], i, true);
  246.                     }
  247.                 else
  248.                     CheckItem(myMenus[sizeM], i, false);
  249.             }
  250.         
  251.             /*
  252.                 if it's not a size in the menu,and there is only one size in the
  253.               selection range check the other item
  254.             */
  255.             
  256.             if (!sizeinMenu && (contMode & doSize) != 0)
  257.               CheckItem(myMenus[sizeM], max, true);
  258.             else
  259.                 CheckItem(myMenus[sizeM], max, false);
  260.  
  261.             /*if this is an outline font, set the rest of the items to outline style*/
  262.             /*RealFont will ensure that the sizes are outlined*/
  263.  
  264.             oldState = GetOutlinePreferred();
  265.             SetOutlinePreferred(true);
  266.             for (i = max-4; i <= max; i++)
  267.                 {
  268.                     if (IsOutline(numer, numer) && (contMode & doFont)!= 0)
  269.                         SetItemStyle(myMenus[sizeM], i, outline);
  270.                     else
  271.                         SetItemStyle(myMenus[sizeM], i, 0);
  272.                 }
  273.                 
  274.             SetOutlinePreferred(oldState);
  275.     }
  276.  
  277. /**-----------------------------------------------------------------------
  278.     Name:       SetEditMenu
  279.     Purpose:    Set the text of the edit menu according to the state of
  280.                                 current document.
  281.   -----------------------------------------------------------------------**/
  282.  
  283. #pragma segment Utils
  284.  
  285. pascal void SetEditMenu(DPtr theDoc)
  286.     {
  287.         if (theDoc->showBorders)
  288.             SetItem(myMenus[editM], cBorders, (unsigned char *)"\pHide Borders");
  289.         else
  290.             SetItem(myMenus[editM], cBorders, (unsigned char *)"\pShow Borders");
  291.     }  /* SetEditMenu */
  292.             
  293. /**-----------------------------------------------------------------------
  294.     Name:       SetFontMenu
  295.     Purpose:    Set the font menu according to the state of
  296.                                 current selection of the supplied document.
  297.   -----------------------------------------------------------------------**/
  298. #pragma segment Utils
  299.         
  300. pascal void SetFontMenu(DPtr theDoc)
  301.   {
  302.     MenuHandle        theMHandle;
  303.     short         theNumber;
  304.     short         i;
  305.     short                max;
  306.     Str255        name;
  307.     TextStyle     theStyle;
  308.         short         contMode;
  309.  
  310.         theMHandle = GetMHandle(mfontID);
  311.  
  312.         if (gFontMItem)
  313.       CheckItem(theMHandle, gFontMItem, false);
  314.             
  315.         max = CountMItems(theMHandle);
  316.  
  317.         contMode = doFont;
  318.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  319.  
  320.         gFontMItem = 0;
  321.         
  322.     if (contMode & doFont)
  323.             for (i=1; i<=max; i++)
  324.                 {
  325.                     GetItem(theMHandle, i, name);
  326.                     GetFNum(name, &theNumber);
  327.                     if (theNumber == theStyle.tsFont)
  328.                         gFontMItem = i;
  329.                 }
  330.  
  331.     if (gFontMItem)
  332.       CheckItem(theMHandle, gFontMItem, true);
  333.             
  334.         SetSizeMenu(theDoc);
  335.         SetStyleMenu(theDoc);
  336.     }
  337.  
  338. /**-----------------------------------------------------------------------
  339.     Name:       GetTempFileName
  340.     Purpose:    Fills newstring with a temporary file name.
  341.   -----------------------------------------------------------------------**/
  342.  
  343. #pragma segment Utils
  344.  
  345. pascal void GetTempFileName(DPtr aDoc,
  346.                             Str255 newString)
  347.  
  348.     {
  349.        Str255        s;
  350.      Str255        fileName;
  351.  
  352.         if (aDoc->everSaved == false)
  353.           PLstrcpy(fileName, (unsigned char *)"\pTEXTra");
  354.         else
  355.             PLstrcpy(fileName, aDoc->theFileName);
  356.  
  357.     /*generate a unique(ish) temporary filename*/
  358.         
  359.         if (fileName[0] > 21)
  360.           fileName[0] = 21;
  361.                 
  362.         NumToString(TickCount(), s);
  363.         
  364.         PLstrcat(fileName, s);
  365.         
  366.         PLstrcpy(newString,fileName);
  367.     }
  368.  
  369. /**-----------------------------------------------------------------------
  370.     Name:       SetText
  371.     Purpose:    Sets the text of the supplied itemNo in aDialog to 
  372.                                 theString and select it.
  373.   -----------------------------------------------------------------------**/
  374.  
  375. #pragma segment Utils
  376.  
  377. pascal void SetText(DialogPtr aDialog,
  378.                     short     itemNo,
  379.                     Str255    theString)
  380.   {
  381.     Handle      itemHandle;
  382.     Rect        box;
  383.     short       kind;
  384.     TEHandle    theTEHandle;
  385.  
  386.         GetDItem(aDialog, itemNo, &kind, &itemHandle, &box);
  387.         SetIText(itemHandle, theString);
  388.         
  389.         theTEHandle = ((DialogPeek)aDialog)->textH;
  390.  
  391.         /*set all the text to be selected*/
  392.         if (theTEHandle)
  393.             TESetSelect(0, 255, theTEHandle);
  394.     }
  395.             
  396. /**-----------------------------------------------------------------------
  397.     Name:       RetrieveText
  398.     Purpose:    Returns the text of anItem in aDialog in aString.
  399.   -----------------------------------------------------------------------**/
  400.  
  401. #pragma segment Utils
  402.  
  403. pascal void RetrieveText(DialogPtr aDialog,
  404.                                                short     anItem,
  405.                                                Str255    aString)
  406.   {
  407.      short      kind;
  408.      Rect       box;
  409.      Handle     itemHandle;
  410.  
  411.          GetDItem(aDialog, anItem, &kind, &itemHandle, &box);
  412.          GetIText(itemHandle, aString);
  413.   }
  414.  
  415. /**-----------------------------------------------------------------------
  416.     Name:       DrawDefaultOutline
  417.     Purpose:    Draws an outline around theItem.
  418.                                 Called as a useritem Proc by the dialog manager.
  419.                                 To use place a useritem over the default item in the
  420.                                 dialog and install the address of this proc as the item
  421.                                 handle.
  422.   -----------------------------------------------------------------------**/
  423.  
  424. #pragma segment Utils
  425.  
  426. pascal void DrawDefaultOutline(DialogPtr theDialog, short theItem)
  427.   {
  428.       short       kind;
  429.     Handle      itemHandle;
  430.     Rect        box;
  431.                 
  432.     GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  433.     PenSize(3, 3);
  434.     InsetRect(&box, - 4, - 4);
  435.     FrameRoundRect(&box, 16, 16);
  436.     PenNormal();
  437.         
  438.     }  /* DrawDefaultOutline */
  439.             
  440. /**-----------------------------------------------------------------------
  441.     Name:       AdornDefaultButton
  442.     Purpose:    Installs DrawDefaultOutline as the useritem proc
  443.                     for the given item.
  444.   -----------------------------------------------------------------------**/
  445.  
  446. #pragma segment Utils
  447.         
  448. pascal void AdornDefaultButton(DialogPtr theDialog,short theItem)
  449.   {
  450.       short       kind;
  451.     Handle      itemHandle;
  452.     Rect        box;
  453.  
  454.         GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  455.         SetDItem(theDialog, theItem, kind, (Handle)&DrawDefaultOutline, &box);
  456.   }
  457.  
  458.     /*-------  Determining of Gestalt is available ---------------*/
  459.     /*The following routines come from the Inside Mac VI recommendations*/
  460.     /*about how to find if a trap is available*/
  461.          /*
  462.             The glue for Gestalt will be in MPW 3.2, so if it is available we will also
  463.              need to check the system version
  464.         */
  465.  
  466. pascal void GetRectOfDialogItem(DialogPtr theDialog, short theItem, Rect *theRect)
  467.     {
  468.       short       kind;
  469.     Handle      itemHandle;
  470.         
  471.         GetDItem(theDialog, theItem, &kind, &itemHandle, theRect);
  472.     }
  473.  
  474. #pragma segment Utils
  475.  
  476. pascal short NumToolboxTraps()
  477.   {
  478.         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  479.             return(0x200);
  480.         else
  481.             return(0x400);
  482.     }
  483.  
  484. #pragma segment Utils
  485.  
  486. #define TrapMask  0x0800
  487.  
  488. pascal TrapType GetTrapType(short theTrap)
  489.   {
  490.         if ((theTrap & TrapMask) > 0)
  491.             return(ToolTrap);
  492.         else
  493.             return(OSTrap);
  494.     }
  495.  
  496. #pragma segment Utils
  497.  
  498. pascal Boolean TrapAvailable(short theTrap)
  499.   {
  500.         TrapType  tType;
  501.  
  502.         tType = GetTrapType(theTrap);
  503.         if (tType == ToolTrap)
  504.             {
  505.                 theTrap = theTrap & 0x07FF;
  506.                 if (theTrap >= NumToolboxTraps())
  507.                     theTrap = _Unimplemented;
  508.             }
  509.         return(NGetTrapAddress(theTrap, tType) != NGetTrapAddress(_Unimplemented,ToolTrap));
  510.     }
  511.  
  512. #pragma segment Utils
  513.  
  514. #define _Gestalt 0xA1AD
  515.  
  516. pascal Boolean GestaltAvailable()
  517.   {
  518.         return(TrapAvailable(_Gestalt));
  519.     }
  520.  
  521. /**------  FeatureIsImplemented    ------------**/
  522. /*This is called to use Gestalt to determine if a feature is implemented.
  523.  This applies to only those referenced by OSType*/
  524.  
  525. #pragma segment Utils
  526.  
  527. pascal Boolean FeatureIsImplemented(OSType  theFeature,
  528.                                                           short   theTestBit)
  529.   {
  530.     OSErr     err;
  531.     long      result;
  532.  
  533.         err = Gestalt(theFeature, &result);
  534.         if (err == noErr)
  535.             if (BitTst(&result, 31 -theTestBit))
  536.                 return(true);
  537.       return(false);
  538.     }
  539.  
  540. #pragma segment Utils
  541.  
  542. pascal Boolean CheckEnvironment()
  543.   {
  544.         /*
  545.          first determine of Gestalt is available- if it isn't exit
  546.          as we only run under 7.0.  It could it present in 6.04 - so we need
  547.          to do some further checks for important features
  548.         */
  549.  
  550.         gGestaltAvailable = GestaltAvailable();
  551.         
  552.         if (!gGestaltAvailable)
  553.             return(false);
  554.  
  555.     /*first check if the Edition Manager is present*/
  556.                 
  557.     gEditionManagerImplemented = FeatureIsImplemented(gestaltEditionMgrAttr,
  558.                                                                                                           gestaltEditionMgrPresent);
  559.  
  560.         /*and for good measure- the Alias manager*/
  561.                 
  562.         gAliasManagerImplemented  = FeatureIsImplemented(gestaltAliasMgrAttr,
  563.                                                                                                          gestaltAliasMgrPresent);
  564.             
  565.         /*check for the AppleEvents manager - we certainly can't work without it*/
  566.         
  567.         gAppleEventsImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,
  568.                                                                                                          gestaltAppleEventsPresent);
  569.         
  570.         /*check if recording is implemented*/
  571.         
  572.         gRecordingImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,1);
  573.             
  574.         /*check for the Outline fonts*/
  575.         
  576.         gOutlineFontsImplemented  = FeatureIsImplemented(gestaltFontMgrAttr,
  577.                                                                                                          gestaltOutlineFonts);
  578.         
  579.         return (gEditionManagerImplemented &&
  580.                         gAliasManagerImplemented   &&
  581.                         gAppleEventsImplemented    &&
  582.                         gOutlineFontsImplemented);
  583.                                 
  584.     }  /* CheckEnvironment */
  585.             
  586.     /*
  587.         DoPageSetup returns true if the page setup of the document is altered
  588.     */
  589.     
  590.     pascal Boolean DoPageSetup(DPtr theDoc)
  591.         {
  592.             Boolean result = false;
  593.                 
  594.                 if (theDoc)
  595.                     {
  596.                         PrOpen();
  597.                         result =  PrStlDialog(theDoc->thePrintSetup);
  598.                         PrClose();
  599.                     }
  600.                     
  601.                 return(result);
  602.         }  /* DoPageSetup */
  603.  
  604. /*
  605.     Name:    CtrlKeyPressed
  606.     Purpose: Returns true if control key pressed during event
  607. */
  608. pascal Boolean CtrlKeyPressed(const EventRecord *theEvent)
  609.     {
  610.         return((theEvent->modifiers & controlKey) != 0);
  611.     }
  612.     
  613. /*
  614.     Name:    OptionKeyPressed
  615.     Purpose: Returns true if option key pressed during event
  616. */
  617. pascal Boolean OptionKeyPressed(const EventRecord *theEvent)
  618.     {
  619.         return((theEvent->modifiers & optionKey) != 0);
  620.     }
  621.